home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / zfont.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-09  |  11.5 KB  |  414 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zfont.c */
  20. /* Generic font operators */
  21. #include "ghost.h"
  22. #include "errors.h"
  23. #include "oper.h"
  24. #include "gsstruct.h"        /* for registering root */
  25. #include "gzstate.h"        /* must precede gxdevice */
  26. #include "gxdevice.h"        /* must precede gxfont */
  27. #include "gschar.h"
  28. #include "gxfont.h"
  29. #include "gxfcache.h"
  30. #include "bfont.h"
  31. #include "ialloc.h"
  32. #include "idict.h"
  33. #include "igstate.h"
  34. #include "iname.h"        /* for name_mark_index */
  35. #include "isave.h"
  36. #include "store.h"
  37. #include "ivmspace.h"
  38.  
  39. /* Forward references */
  40. private int make_font(P2(os_ptr, const gs_matrix *));
  41. private void make_uint_array(P3(os_ptr, const uint *, int));
  42.  
  43. /* The (global) font directory */
  44. gs_font_dir *ifont_dir = 0;        /* needed for buildfont */
  45. private gs_gc_root_t font_dir_root;
  46.  
  47. /* Mark a glyph as a PostScript name (if it isn't a CID). */
  48. bool
  49. zfont_mark_glyph_name(gs_glyph glyph, void *ignore_data)
  50. {    return (glyph >= gs_min_cid_glyph || glyph == gs_no_glyph ? false :
  51.         name_mark_index((uint)glyph));
  52. }
  53.  
  54. /* Initialize the font operators */
  55. private void
  56. zfont_init(void)
  57. {    ifont_dir = gs_font_dir_alloc(imemory);
  58.     ifont_dir->ccache.mark_glyph = zfont_mark_glyph_name;
  59.     gs_register_struct_root(imemory, &font_dir_root,
  60.                 (void **)&ifont_dir, "ifont_dir");
  61. }
  62.  
  63. /* <font> <scale> scalefont <new_font> */
  64. private int
  65. zscalefont(register os_ptr op)
  66. {    int code;
  67.     float scale;
  68.     gs_matrix mat;
  69.     if ( (code = num_params(op, 1, &scale)) < 0 )
  70.       return code;
  71.     if ( (code = gs_make_scaling(scale, scale, &mat)) < 0 )
  72.       return code;
  73.     return make_font(op, &mat);
  74. }
  75.  
  76. /* <font> <matrix> makefont <new_font> */
  77. private int
  78. zmakefont(register os_ptr op)
  79. {    int code;
  80.     gs_matrix mat;
  81.     if ( (code = read_matrix(op, &mat)) < 0 )
  82.       return code;
  83.     return make_font(op, &mat);
  84. }
  85.  
  86. /* <font> setfont - */
  87. int
  88. zsetfont(register os_ptr op)
  89. {    gs_font *pfont;
  90.     int code = font_param(op, &pfont);
  91.     if ( code < 0 || (code = gs_setfont(igs, pfont)) < 0 )
  92.       return code;
  93.     pop(1);
  94.     return code;
  95. }
  96.  
  97. /* - currentfont <font> */
  98. private int
  99. zcurrentfont(register os_ptr op)
  100. {    push(1);
  101.     *op = *pfont_dict(gs_currentfont(igs));
  102.     return 0;
  103. }
  104.  
  105. /* - cachestatus <mark> <bsize> <bmax> <msize> <mmax> <csize> <cmax> <blimit> */
  106. private int
  107. zcachestatus(register os_ptr op)
  108. {    uint status[7];
  109.     gs_cachestatus(ifont_dir, status);
  110.     push(7);
  111.     make_uint_array(op - 6, status, 7);
  112.     return 0;
  113. }
  114.  
  115. /* <blimit> setcachelimit - */
  116. private int
  117. zsetcachelimit(register os_ptr op)
  118. {    check_int_leu(*op, max_uint);
  119.     gs_setcachelimit(ifont_dir, (uint)op->value.intval);
  120.     pop(1);
  121.     return 0;
  122. }
  123.  
  124. /* <mark> <size> <lower> <upper> setcacheparams - */
  125. private int
  126. zsetcacheparams(register os_ptr op)
  127. {    uint params[3];
  128.     int i, code;
  129.     os_ptr opp = op;
  130.  
  131.     for ( i = 0; i < 3 && !r_has_type(opp, t_mark) ; i++, opp-- )
  132.        {    check_int_leu(*opp, max_uint);
  133.         params[i] = opp->value.intval;
  134.        }
  135.     switch ( i )
  136.        {
  137.     case 3:
  138.         if ( (code = gs_setcachesize(ifont_dir, params[2])) < 0 )
  139.           return code;
  140.     case 2:
  141.         if ( (code = gs_setcachelower(ifont_dir, params[1])) < 0 )
  142.           return code;
  143.     case 1:
  144.         if ( (code = gs_setcacheupper(ifont_dir, params[0])) < 0 )
  145.           return code;
  146.     case 0: ;
  147.        }
  148.     return zcleartomark(op);
  149. }
  150.  
  151. /* - currentcacheparams <mark> <size> <lower> <upper> */
  152. private int
  153. zcurrentcacheparams(register os_ptr op)
  154. {    uint params[3];
  155.  
  156.     params[0] = gs_currentcachesize(ifont_dir);
  157.     params[1] = gs_currentcachelower(ifont_dir);
  158.     params[2] = gs_currentcacheupper(ifont_dir);
  159.     push(4);
  160.     make_mark(op - 3);
  161.     make_uint_array(op - 2, params, 3);
  162.     return 0;
  163. }
  164.  
  165. /* ------ Initialization procedure ------ */
  166.  
  167. BEGIN_OP_DEFS(zfont_op_defs) {
  168.     {"0currentfont", zcurrentfont},
  169.     {"2makefont", zmakefont},
  170.     {"2scalefont", zscalefont},
  171.     {"1setfont", zsetfont},
  172.     {"0cachestatus", zcachestatus},
  173.     {"1setcachelimit", zsetcachelimit},
  174.     {"1setcacheparams", zsetcacheparams},
  175.     {"0currentcacheparams", zcurrentcacheparams},
  176. END_OP_DEFS(zfont_init) }
  177.  
  178. /* ------ Subroutines ------ */
  179.  
  180. /* Validate a font parameter. */
  181. int
  182. font_param(const ref *pfdict, gs_font **ppfont)
  183. {    /*
  184.      * Check that pfdict is a read-only dictionary, that it has a FID
  185.      * entry whose value is a fontID, and that the fontID points to a
  186.      * gs_font structure whose associated PostScript dictionary is
  187.      * pfdict.
  188.      */
  189.     ref *pid;
  190.     gs_font *pfont;
  191.     const font_data *pdata;
  192.  
  193.     check_type(*pfdict, t_dictionary);
  194.     if ( dict_find_string(pfdict, "FID", &pid) <= 0 ||
  195.          !r_has_type(pid, t_fontID)
  196.        )
  197.       return_error(e_invalidfont);
  198.     pfont = r_ptr(pid, gs_font);
  199.     pdata = pfont->client_data;
  200.     if ( !obj_eq(&pdata->dict, pfdict) )
  201.       return_error(e_invalidfont);
  202.     *ppfont = pfont;
  203.     if ( pfont == 0 )
  204.       return_error(e_invalidfont); /* unregistered font */
  205.     return 0;
  206. }
  207.  
  208. /* Add the FID entry to a font dictionary. */
  209. int
  210. add_FID(ref *fp    /* t_dictionary */,  gs_font *pfont)
  211. {    ref fid;
  212.     make_tav_new(&fid, t_fontID, a_readonly | icurrent_space,
  213.              pstruct, (void *)pfont);
  214.     return dict_put_string(fp, "FID", &fid);
  215. }
  216.  
  217. /* Make a transformed font (common code for makefont/scalefont). */
  218. private int
  219. make_font(os_ptr op, const gs_matrix *pmat)
  220. {    os_ptr fp = op - 1;
  221.     gs_font *oldfont, *newfont;
  222.     int code;
  223.     ref *pencoding = 0;
  224.  
  225.     code = font_param(fp, &oldfont);
  226.     if ( code < 0 )
  227.       return code;
  228.       {    uint space = ialloc_space(idmemory);
  229.         ialloc_set_space(idmemory, r_space(fp));
  230.         if ( dict_find_string(fp, "Encoding", &pencoding) > 0 &&
  231.             !r_is_array(pencoding)
  232.            )
  233.           code = gs_note_error(e_invalidfont);
  234.         else
  235.           {    /*
  236.              * Temporarily substitute the new dictionary
  237.              * for the old one, in case the Encoding changed.
  238.              */
  239.             ref olddict;
  240.             olddict = *pfont_dict(oldfont);
  241.             *pfont_dict(oldfont) = *fp;
  242.             code = gs_makefont(ifont_dir, oldfont, pmat, &newfont);
  243.             *pfont_dict(oldfont) = olddict;
  244.           }
  245.         ialloc_set_space(idmemory, space);
  246.           }
  247.     if ( code < 0 )
  248.       return code;
  249.     /*
  250.      * We have to allow for the possibility that the font's Encoding
  251.      * is different from that of the base font.  Note that the
  252.      * font_data of the new font was simply copied from the old one.
  253.      */
  254.     if ( pencoding != 0 &&
  255.          !obj_eq(pencoding, &pfont_data(newfont)->Encoding)
  256.        )
  257.       {    if ( newfont->FontType == ft_composite )
  258.           return_error(e_rangecheck);
  259.         /* We should really do validity checking here.... */
  260.         ref_assign(&pfont_data(newfont)->Encoding, pencoding);
  261.         lookup_gs_simple_font_encoding((gs_font_base *)newfont);
  262.       }
  263.     *fp = *pfont_dict(newfont);
  264.     pop(1);
  265.     return 0;
  266. }
  267. /* Create the transformed font dictionary. */
  268. /* This is the make_font completion procedure for all non-composite fonts */
  269. /* created at the interpreter level (see build_gs_simple_font in zfont2.c.) */
  270. int
  271. zbase_make_font(gs_font_dir *pdir, const gs_font *oldfont,
  272.   const gs_matrix *pmat, gs_font **ppfont)
  273. {    /* We must call gs_base_make_font so that the XUID gets copied */
  274.     /* if necessary. */
  275.     int code = gs_base_make_font(pdir, oldfont, pmat, ppfont);
  276.     if ( code < 0 )
  277.       return code;
  278.     return zdefault_make_font(pdir, oldfont, pmat, ppfont);
  279. }
  280. int
  281. zdefault_make_font(gs_font_dir *pdir, const gs_font *oldfont,
  282.   const gs_matrix *pmat, gs_font **ppfont)
  283. {    gs_font *newfont = *ppfont;
  284.     ref *fp = pfont_dict(oldfont);
  285.     font_data *pdata;
  286.     ref newdict, newmat, scalemat;
  287.     uint dlen = dict_maxlength(fp);
  288.     uint mlen = dict_length(fp) + 3;  /* FontID, OrigFont, ScaleMatrix */
  289.     int code;
  290.  
  291.     if ( dlen < mlen )
  292.       dlen = mlen;
  293.     if ( (pdata = ialloc_struct(font_data, &st_font_data,
  294.                     "make_font(font_data)")) == 0
  295.        )
  296.       return_error(e_VMerror);
  297.     if ( (code = dict_create(dlen, &newdict)) < 0 ||
  298.          (code = dict_copy(fp, &newdict)) < 0 ||
  299.          (code = ialloc_ref_array(&newmat, a_all, 12, "make_font(matrices)")) < 0
  300.        )
  301.       return code;
  302.     refset_null(newmat.value.refs, 12);
  303.     ref_assign(&scalemat, &newmat);
  304.     r_set_size(&scalemat, 6);
  305.     scalemat.value.refs += 6;
  306.     /*
  307.      * Create the scaling matrix.  We could do this several different
  308.      * ways: by "dividing" the new FontMatrix by the base FontMatrix, by
  309.      * multiplying the current scaling matrix by a ScaleMatrix kept in
  310.      * the gs_font, or by multiplying the current scaling matrix by the
  311.      * ScaleMatrix from the font dictionary.  We opt for the last of
  312.      * these.
  313.      */
  314.     { gs_matrix scale, prev_scale;
  315.       ref *ppsm;
  316.       if ( !(dict_find_string(fp, "ScaleMatrix", &ppsm) > 0 &&
  317.          read_matrix(ppsm, &prev_scale) >= 0 &&
  318.          gs_matrix_multiply(pmat, &prev_scale, &scale) >= 0)
  319.          )
  320.         scale = *pmat;
  321.       write_matrix(&scalemat, &scale);
  322.     }
  323.     r_clear_attrs(&scalemat, a_write);
  324.     r_set_size(&newmat, 6);
  325.     write_matrix(&newmat, &newfont->FontMatrix);
  326.     r_clear_attrs(&newmat, a_write);
  327.     if ( (code = dict_put_string(&newdict, "FontMatrix", &newmat)) < 0 ||
  328.          (code = dict_put_string(&newdict, "OrigFont", pfont_dict(oldfont->base))) < 0 ||
  329.          (code = dict_put_string(&newdict, "ScaleMatrix", &scalemat)) < 0 ||
  330.          (code = add_FID(&newdict, newfont)) < 0
  331.        )
  332.       return code;
  333.     newfont->client_data = pdata;
  334.     *pdata = *pfont_data(oldfont);
  335.     pdata->dict = newdict;
  336.     r_clear_attrs(dict_access_ref(&newdict), a_write);
  337.     return 0;
  338. }
  339.  
  340. /* Convert an array of (unsigned) integers to stack form. */
  341. private void
  342. make_uint_array(register os_ptr op, const uint *intp, int count)
  343. {    int i;
  344.     for ( i = 0; i < count; i++, op++, intp++ )
  345.         make_int(op, *intp);
  346. }
  347.  
  348. /* Remove scaled font and character cache entries that would be */
  349. /* invalidated by a restore. */
  350. private bool
  351. purge_if_name_removed(cached_char *cc, void *vsave)
  352. {    return alloc_name_index_is_since_save(cc->code, vsave);
  353. }
  354. void
  355. font_restore(const alloc_save_t *save)
  356. {    gs_font_dir *pdir = ifont_dir;
  357.     if ( pdir == 0 )        /* not initialized yet */
  358.         return;
  359.  
  360.     /* Purge original (unscaled) fonts. */
  361.  
  362.     {    gs_font *pfont;
  363. otop:        for ( pfont = pdir->orig_fonts; pfont != 0;
  364.               pfont = pfont->next
  365.             )
  366.         { if ( alloc_is_since_save((char *)pfont, save) )
  367.            { gs_purge_font(pfont); goto otop; }
  368.         }
  369.     }
  370.  
  371.     /* Purge cached scaled fonts. */
  372.  
  373.     {    gs_font *pfont;
  374. top:        for ( pfont = pdir->scaled_fonts; pfont != 0;
  375.               pfont = pfont->next
  376.             )
  377.         { if ( alloc_is_since_save((char *)pfont, save) )
  378.            { gs_purge_font(pfont); goto top; }
  379.         }
  380.     }
  381.  
  382.     /* Purge xfonts and uncached scaled fonts. */
  383.  
  384.     {    cached_fm_pair *pair;
  385.         uint n;
  386.         for ( pair = pdir->fmcache.mdata, n = pdir->fmcache.mmax;
  387.               n > 0; pair++, n--
  388.             )
  389.           if ( !fm_pair_is_free(pair) )
  390.         {    if ( (pair->font != 0 &&
  391.                   alloc_is_since_save((char *)pair->font, save)) ||
  392.                  (uid_is_XUID(&pair->UID) &&
  393.                   alloc_is_since_save((char *)pair->UID.xvalues,
  394.                           save))
  395.                )
  396.                 gs_purge_fm_pair(pdir, pair, 0);
  397.             else
  398.             if ( pair->xfont != 0 &&
  399.                  alloc_is_since_save((char *)pair->xfont, save)
  400.                )
  401.                 gs_purge_fm_pair(pdir, pair, 1);
  402.         }
  403.     }
  404.  
  405.     /* Purge characters with names about to be removed. */
  406.     /* We only need to do this if any new names have been created */
  407.     /* since the save. */
  408.  
  409.     if ( alloc_any_names_since_save(save) )
  410.       gx_purge_selected_cached_chars(pdir, purge_if_name_removed,
  411.                      (void *)save);
  412.  
  413. }
  414.